Skip to content

Convert boost stacktrace to git submodule #116

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom
Merged
merged 13 commits into from
Jun 3, 2025
Merged

Convert boost stacktrace to git submodule #116

merged 13 commits into from
Jun 3, 2025

Conversation

eljonny
Copy link
Owner

@eljonny eljonny commented Jun 3, 2025

This branch converts the dependency structure from static files to git submodules.

eljonny added 7 commits June 1, 2025 01:24
@eljonny
Add Boost::stacktrace at 1.88.0 as a submodule of the project.
bd899df
@eljonny
Add all Boost::stacktrace dependencies as submodules, set everything …
646dfb1 
…to boost-1.88.0, then hook them up to the CMake build through Linking.cmake and the new Boost.Stacktrace.cmake... now just have to figure out the install for the TestCPP target.
@eljonny
Update URLs to the newly create CMake Git submodule dep repos, etc
305a61a 
I have forked the necessary repos into my own GH account, added the
 small required CMake modification to each project, verified build/
 test, and tagged each update appropriately, which is where the state
 of the repos here are now.
So in the future when Boost releases, this is the process:
 - Sync the boost dependency forks
 - Check out the new release tags
 - Apply the CMakeLists.txt changes from the previous
    *-cmake-git-submodule tags
 - Commit and retag with the appropriate release
 - Push the tag
 - Update TestCPP, create issue, PR, and link to milestone
 - Build/test/CI with the new tags
 - Fix any issues

At this point, the Boost.Stacktrace dependency and its transitives
 are set up as Git submodules and everything is working.
I think this is a much better way to manage the dependencies than
 manually merging everything from the new release in every time,
 and it tells the person which Boost.Stacktrace version the current
 version of the library depends on, and how that is connected to
 upstream.
It also helps to not be just using whatever the latest develop HEAD was
 at the time I updated it last.

Added a generic tag message for when a new Boost release is pulled in
 and retagged with the CMakeLists.txt changes.
@eljonny
Convert Boost.Stacktrace and transitives to git submodules and related
5886c40 
Added new SubmodulesInit include to top-level CMakeLists.txt.
This ensures CMake updates all the dependencies that are git submodules
 so everything is at the right tag/commit and exists.
SubmodulesInit.cmake is fully implemented and derived from
https://cliutils.gitlab.io/modern-cmake/chapters/projects/submodule.html

No need to conditionally worry about including from Boost.Stacktrace
 since it is now handled through the git submodule dependencies.
Includes.cmake is altered to take this into account.

Add the required boost_* targets to the install target to ensure the
 necessary files are there to support the library when TestCPP gets
 installed.
These targets are identified and added to the list in
 Boost.Stacktrace.cmake.
Formatting.

Update the TestCPP package email contact to the appropriate HSF email
 address.

Implement a more selective and proper Boost.Stacktrace.cmake.
This version is easier to maintain if the Boost.Stacktrace dependencies
 change in the future.
It also lays out what targets to install given the environment we're
 building in.
@eljonny
Targeted Git submodule dependencies init;improve Boost.Stacktrace.cmake
4bfc256 
Only run submodule init if the dependencies are actually used.

Link to the proper library targets for each scenario, and break down
 all the build scenarios so it's clear which scenario gets which
 Boost.Stacktrace implementation, or fall back on Boost::stacktrace
 in case it is unclear what is supported.
@eljonny
Compile Defs for ClangCL, formatting, further Boost.Stacktrace work
2fe82e0 
Formatting that makes it clear where the list items begin.

Ensure using Boost::stacktrace_basic if addr2line and backtrace are not
 found to enable at least limited backtracing.
Make sure the STREQUAL is wrapped, just to make it clear.

ClangCL requires notification through the BOOST_STACKTRACE_USE_WINDBG
 compile definition to ensure it uses WinDbg, ole32, and dbgeng.
@eljonny
Ensure README has accurate information about Boost.Stacktrace
42664f0 
And how using Boost.Stacktrace affects compatibility of the library w/
 C++11, since it requires C++14.

Fix casing.
@eljonny eljonny added this to the 0.8-release milestone Jun 3, 2025
@eljonny eljonny self-assigned this Jun 3, 2025
@eljonny eljonny added the enhancement New feature or request label Jun 3, 2025
@eljonny eljonny linked an issue Jun 3, 2025 that may be closed by this pull request
Convert Boost::stacktrace to a git submodule and dynamic CMake dependency #114
Closed
@github-actions GitHub Actions
Copy link

github-actions bot commented Jun 3, 2025 •
edited
Loading

⚡ Static analysis result ⚡

🔴 clang-tidy found 180 issues! Click here to see details.

TestCPP/src/TestCPPExceptions.cpp

Lines 28 to 33 in d2902ae

#include <iostream>
#include "internal/TestCPPExceptions.h"
#ifdef TESTCPP_STACKTRACE_ENABLED
#include <boost/stacktrace.hpp> 

!Line: 28 - error: included header iostream is not used directly [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPExceptions.cpp

Lines 37 to 42 in d2902ae

using std::string;
using std::runtime_error;
namespace TestCPP {
TestCPPException::TestCPPException (const char * msg) : 

!Line: 37 - error: no header providing "std::string" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPExceptions.cpp

Lines 38 to 43 in d2902ae

using std::runtime_error;
namespace TestCPP {
TestCPPException::TestCPPException (const char * msg) :
runtime_error(msg) 

!Line: 38 - error: no header providing "std::runtime_error" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPExceptions.cpp

Lines 66 to 71 in d2902ae

TestCPPException(std::move(msg))
{
#ifdef TESTCPP_STACKTRACE_ENABLED
clog << boost::stacktrace::stacktrace();
#endif
} 

!Line: 66 - error: std::move of the const variable 'msg' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 49 - note: consider changing the 1st parameter of 'TestCPPException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/src/TestCPPExceptions.cpp

Lines 66 to 71 in d2902ae

TestCPPException(std::move(msg))
{
#ifdef TESTCPP_STACKTRACE_ENABLED
clog << boost::stacktrace::stacktrace();
#endif
} 

!Line: 66 - error: no header providing "std::move" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/include/internal/TestCPPCommon.h

Lines 88 to 93 in d2902ae

static constexpr const char * SP = " ";
static constexpr const char * START_RUN =
"Starting run of test ";
static constexpr const char * SUITE = "Suite ";
static constexpr const char * SUITE_TESTS_PASSED =
" suite tests passed!"; 

!Line: 88 - error: variable name 'SP' is too short, expected at least 3 characters [readability-identifier-length,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 73 to 78 in d2902ae

TestObjName (const char* name);
/**
* @brief Get the encapsulated name for the TestCPP object that
* holds this object.
* @return The name of the TestCPP object that this object 

!Line: 73 - error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [hicpp-explicit-conversions,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 81 to 86 in d2902ae

const string& getName () const;
/**
* @brief Output the test object name to the specified stream.
* @param s The stream to output to.
* @param tcName The test object name object. 

!Line: 81 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 89 to 94 in d2902ae

friend std::ostream& operator<< (
std::ostream& s,
const TestObjName& tcName
);
private: 

!Line: 89 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 90 to 95 in d2902ae

std::ostream& s,
const TestObjName& tcName
);
private:
string testCaseName; 

!Line: 90 - error: parameter name 's' is too short, expected at least 3 characters [readability-identifier-length,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 106 to 111 in d2902ae

template <class T> class no_destroy {
// Flawfinder: ignore
alignas(T) unsigned char data[sizeof(T)];
public:
template <class... Ts> no_destroy(Ts&&... ts) { new (data) T(std::forward<Ts>(ts)...); }
T& get() { return *reinterpret_cast<T*>(data); } 

!Line: 106 - error: constructor does not initialize these fields: data [cppcoreguidelines-pro-type-member-init,hicpp-member-init,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 108 to 113 in d2902ae

alignas(T) unsigned char data[sizeof(T)];
public:
template <class... Ts> no_destroy(Ts&&... ts) { new (data) T(std::forward<Ts>(ts)...); }
T& get() { return *reinterpret_cast<T*>(data); }
}; 

!Line: 108 - error: do not declare C-style arrays, use 'std::array' instead [cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 110 to 115 in d2902ae

template <class... Ts> no_destroy(Ts&&... ts) { new (data) T(std::forward<Ts>(ts)...); }
T& get() { return *reinterpret_cast<T*>(data); }
};
/**
* @brief Log a message that will only be output when debug 

!Line: 110 - error: constructor does not initialize these fields: data [cppcoreguidelines-pro-type-member-init,hicpp-member-init,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 110 to 115 in d2902ae

template <class... Ts> no_destroy(Ts&&... ts) { new (data) T(std::forward<Ts>(ts)...); }
T& get() { return *reinterpret_cast<T*>(data); }
};
/**
* @brief Log a message that will only be output when debug 

!Line: 110 - error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [hicpp-explicit-conversions,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 110 to 115 in d2902ae

template <class... Ts> no_destroy(Ts&&... ts) { new (data) T(std::forward<Ts>(ts)...); }
T& get() { return *reinterpret_cast<T*>(data); }
};
/**
* @brief Log a message that will only be output when debug 

!Line: 110 - error: parameter name 'ts' is too short, expected at least 3 characters [readability-identifier-length,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 111 to 116 in d2902ae

T& get() { return *reinterpret_cast<T*>(data); }
};
/**
* @brief Log a message that will only be output when debug
* logging is enabled. 

!Line: 111 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 111 to 116 in d2902ae

T& get() { return *reinterpret_cast<T*>(data); }
};
/**
* @brief Log a message that will only be output when debug
* logging is enabled. 

!Line: 111 - error: do not use reinterpret_cast [cppcoreguidelines-pro-type-reinterpret-cast,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 137 to 142 in d2902ae

bool stringContains (const string& source,
const string& contains);
/**
* @brief Safely converts unsigned integer values to signed.
* @param toCast The unsigned value to convert. 

!Line: 137 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 145 to 149 in d2902ae

int unsignedToSigned(unsigned toCast);
}
}
#endif 

!Line: 145 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPUtil.cpp

Lines 51 to 56 in d2902ae

if (name) {
this->testCaseName = name;
}
else {
throw TestCPPException(TCPPStr::NVTN);
} 

!Line: 51 - error: implicit conversion 'const char *' -> 'bool' [readability-implicit-bool-conversion,-warnings-as-errors]

TestCPP/src/TestCPPUtil.cpp

Lines 59 to 64 in d2902ae

const string& TestObjName::getName () const {
return this->testCaseName;
}
std::ostream& operator<< (
std::ostream& s, 

!Line: 59 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPUtil.cpp

Lines 63 to 68 in d2902ae

std::ostream& operator<< (
std::ostream& s,
const TestObjName& tcName
)
{
s << tcName.getName(); 

!Line: 63 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPUtil.cpp

Lines 64 to 69 in d2902ae

std::ostream& s,
const TestObjName& tcName
)
{
s << tcName.getName();
return s; 

!Line: 64 - error: parameter name 's' is too short, expected at least 3 characters [readability-identifier-length,-warnings-as-errors]

TestCPP/src/TestCPPUtil.cpp

Lines 78 to 83 in d2902ae

clog << endl;
}
#endif
}
bool stringContains(const string& source, 

!Line: 78 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPUtil.cpp

Lines 83 to 88 in d2902ae

bool stringContains(const string& source,
const string& contains)
{
return source.find(contains) != string::npos;
} 

!Line: 83 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPUtil.cpp

Lines 89 to 94 in d2902ae

int unsignedToSigned(unsigned toCast) {
if (toCast <= INT_MAX) {
return static_cast<int>(toCast);
}
if (toCast >= static_cast<unsigned>(INT_MIN)) { 

!Line: 89 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 84 to 89 in d2902ae

if (err.size()) {
throw TestFailedException(std::move(err));
}
}
/** 

!Line: 84 - error: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 85 to 90 in d2902ae

throw TestFailedException(std::move(err));
}
}
/**
* @brief Check that something is not equivalent to something 

!Line: 85 - error: std::move of the const variable 'err' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/include/internal/TestCPPAssertions.h

Lines 110 to 115 in d2902ae

if (err.size()) {
throw TestFailedException(std::move(err));
}
}
/** 

!Line: 110 - error: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 111 to 116 in d2902ae

throw TestFailedException(std::move(err));
}
}
/**
* @brief Check that a pointer is null. 

!Line: 111 - error: std::move of the const variable 'err' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/include/internal/TestCPPAssertions.h

Lines 131 to 136 in d2902ae

if (err.size()) {
throw TestFailedException(std::move(err));
}
}
/** 

!Line: 131 - error: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 132 to 137 in d2902ae

throw TestFailedException(std::move(err));
}
}
/**
* @brief Check that a pointer is non-null. 

!Line: 132 - error: std::move of the const variable 'err' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/include/internal/TestCPPAssertions.h

Lines 152 to 157 in d2902ae

if (err.size()) {
throw TestFailedException(std::move(err));
}
}
/** 

!Line: 152 - error: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 153 to 158 in d2902ae

throw TestFailedException(std::move(err));
}
}
/**
* @brief Verify that a function throws something. 

!Line: 153 - error: std::move of the const variable 'err' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/include/internal/TestCPPAssertions.h

Lines 243 to 248 in d2902ae

static const string logTestFailure(
T1 expectationValue, T2 actual,
const string& assertionTypeMessage,
const string& failureMessage,
const bool logValues
) 

!Line: 243 - error: return type 'const string' (aka 'const basic_string<char>') is 'const'-qualified at the top level, which may reduce code readability without improving const correctness [readability-const-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 243 to 248 in d2902ae

static const string logTestFailure(
T1 expectationValue, T2 actual,
const string& assertionTypeMessage,
const string& failureMessage,
const bool logValues
) 

!Line: 243 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 252 to 257 in d2902ae

err << assertionTypeMessage << endl;
err << failureMessage << endl;
if (logValues) {
err << "Expectation value: <" << expectationValue << ">"
<< endl; 

!Line: 252 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 253 to 258 in d2902ae

err << failureMessage << endl;
if (logValues) {
err << "Expectation value: <" << expectationValue << ">"
<< endl;
err << "Actual: <" << actual << ">" << endl; 

!Line: 253 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 265 to 270 in d2902ae

static const string checkEquals(
T1 expected, T2 actual,
const string& failureMessage
)
{
if (expected != actual) { 

!Line: 265 - error: return type 'const string' (aka 'const basic_string<char>') is 'const'-qualified at the top level, which may reduce code readability without improving const correctness [readability-const-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 265 to 270 in d2902ae

static const string checkEquals(
T1 expected, T2 actual,
const string& failureMessage
)
{
if (expected != actual) { 

!Line: 265 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 282 to 287 in d2902ae

static const string checkNotEquals(
T1 shouldNotBe, T2 actual,
const string& failureMessage
)
{
if (shouldNotBe == actual) { 

!Line: 282 - error: return type 'const string' (aka 'const basic_string<char>') is 'const'-qualified at the top level, which may reduce code readability without improving const correctness [readability-const-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 282 to 287 in d2902ae

static const string checkNotEquals(
T1 shouldNotBe, T2 actual,
const string& failureMessage
)
{
if (shouldNotBe == actual) { 

!Line: 282 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 299 to 304 in d2902ae

static const string checkNull(
T ptr,
const string& failureMessage
)
{
bool null = ptr == nullptr; 

!Line: 299 - error: return type 'const string' (aka 'const basic_string<char>') is 'const'-qualified at the top level, which may reduce code readability without improving const correctness [readability-const-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 299 to 304 in d2902ae

static const string checkNull(
T ptr,
const string& failureMessage
)
{
bool null = ptr == nullptr; 

!Line: 299 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 318 to 323 in d2902ae

static const string checkNotNull(
T ptr,
const string& failureMessage
)
{
bool notNull = ptr != nullptr; 

!Line: 318 - error: return type 'const string' (aka 'const basic_string<char>') is 'const'-qualified at the top level, which may reduce code readability without improving const correctness [readability-const-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 318 to 323 in d2902ae

static const string checkNotNull(
T ptr,
const string& failureMessage
)
{
bool notNull = ptr != nullptr; 

!Line: 318 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 387 to 392 in d2902ae

const string TestCPP::Assertions::checkEquals<const char*, const char*>(
const char* expected, const char* actual,
const string& failureMessage
);
template<> 

!Line: 387 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 393 to 398 in d2902ae

const string TestCPP::Assertions::checkNotEquals<const char*, const char*>(
const char* shouldNotBe, const char* actual,
const string& failureMessage
);
#endif 

!Line: 393 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 30 to 35 in d2902ae

using std::clog;
using std::current_exception;
using std::endl;
using std::exception;
using std::exception_ptr;
using std::function; 

!Line: 30 - error: no header providing "std::clog" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 31 to 36 in d2902ae

using std::current_exception;
using std::endl;
using std::exception;
using std::exception_ptr;
using std::function;
using std::rethrow_exception; 

!Line: 31 - error: no header providing "std::current_exception" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 33 to 38 in d2902ae

using std::exception;
using std::exception_ptr;
using std::function;
using std::rethrow_exception;
using std::string;
using std::stringstream; 

!Line: 33 - error: no header providing "std::exception" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 34 to 39 in d2902ae

using std::exception_ptr;
using std::function;
using std::rethrow_exception;
using std::string;
using std::stringstream; 

!Line: 34 - error: no header providing "std::__exception_ptr::exception_ptr" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 35 to 40 in d2902ae

using std::function;
using std::rethrow_exception;
using std::string;
using std::stringstream;
namespace TestCPP { 

!Line: 35 - error: no header providing "std::function" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 36 to 41 in d2902ae

using std::rethrow_exception;
using std::string;
using std::stringstream;
namespace TestCPP { 

!Line: 36 - error: no header providing "std::rethrow_exception" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 37 to 42 in d2902ae

using std::string;
using std::stringstream;
namespace TestCPP {
template<> 

!Line: 37 - error: no header providing "std::string" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 38 to 43 in d2902ae

using std::stringstream;
namespace TestCPP {
template<>
const string Assertions::checkEquals<const char*, const char*>( 

!Line: 38 - error: no header providing "std::stringstream" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 43 to 48 in d2902ae

const string Assertions::checkEquals<const char*, const char*>(
const char* expected, const char* actual,
const string& failureMessage
)
{
if (strcmp(expected, actual)) { 

!Line: 43 - error: return type 'const string' (aka 'const basic_string<char>') is 'const'-qualified at the top level, which may reduce code readability without improving const correctness [readability-const-return-type,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 43 to 48 in d2902ae

const string Assertions::checkEquals<const char*, const char*>(
const char* expected, const char* actual,
const string& failureMessage
)
{
if (strcmp(expected, actual)) { 

!Line: 43 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 48 to 53 in d2902ae

if (strcmp(expected, actual)) {
return logTestFailure(
expected, actual,
equivalenceAssertionMessage,
failureMessage,
true 

!Line: 48 - error: function 'strcmp' is called without explicitly comparing result [bugprone-suspicious-string-compare,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 48 to 53 in d2902ae

if (strcmp(expected, actual)) {
return logTestFailure(
expected, actual,
equivalenceAssertionMessage,
failureMessage,
true 

!Line: 48 - error: no header providing "strcmp" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 48 to 53 in d2902ae

if (strcmp(expected, actual)) {
return logTestFailure(
expected, actual,
equivalenceAssertionMessage,
failureMessage,
true 

!Line: 48 - error: implicit conversion 'int' -> 'bool' [readability-implicit-bool-conversion,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 60 to 65 in d2902ae

const string Assertions::checkNotEquals<const char*, const char*>(
const char* shouldNotBe, const char* actual,
const string& failureMessage
)
{
if (!strcmp(shouldNotBe, actual)) { 

!Line: 60 - error: return type 'const string' (aka 'const basic_string<char>') is 'const'-qualified at the top level, which may reduce code readability without improving const correctness [readability-const-return-type,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 60 to 65 in d2902ae

const string Assertions::checkNotEquals<const char*, const char*>(
const char* shouldNotBe, const char* actual,
const string& failureMessage
)
{
if (!strcmp(shouldNotBe, actual)) { 

!Line: 60 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 65 to 70 in d2902ae

if (!strcmp(shouldNotBe, actual)) {
return logTestFailure(
shouldNotBe, actual,
nonequivalenceAssertionMessage,
failureMessage,
true 

!Line: 65 - error: implicit conversion 'int' -> 'bool' [readability-implicit-bool-conversion,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 83 to 88 in d2902ae

if (err.size()) {
throw TestFailedException(std::move(err));
}
}
template<> 

!Line: 83 - error: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 83 to 88 in d2902ae

if (err.size()) {
throw TestFailedException(std::move(err));
}
}
template<> 

!Line: 83 - error: implicit conversion 'size_type' (aka 'unsigned long') -> 'bool' [readability-implicit-bool-conversion,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 84 to 89 in d2902ae

throw TestFailedException(std::move(err));
}
}
template<>
void Assertions::assertNotEquals<const char*, const char*>( 

!Line: 84 - error: std::move of the const variable 'err' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/src/TestCPPAssertions.cpp

Lines 84 to 89 in d2902ae

throw TestFailedException(std::move(err));
}
}
template<>
void Assertions::assertNotEquals<const char*, const char*>( 

!Line: 84 - error: no header providing "std::move" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 96 to 101 in d2902ae

if (err.size()) {
throw TestFailedException(std::move(err));
}
}
void Assertions::assertThrows ( 

!Line: 96 - error: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 96 to 101 in d2902ae

if (err.size()) {
throw TestFailedException(std::move(err));
}
}
void Assertions::assertThrows ( 

!Line: 96 - error: implicit conversion 'size_type' (aka 'unsigned long') -> 'bool' [readability-implicit-bool-conversion,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 97 to 102 in d2902ae

throw TestFailedException(std::move(err));
}
}
void Assertions::assertThrows (
function<void()> shouldThrow, 

!Line: 97 - error: std::move of the const variable 'err' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/src/TestCPPAssertions.cpp

Lines 102 to 107 in d2902ae

function<void()> shouldThrow,
const string& failureMessage
)
{
try {
shouldThrow(); 

!Line: 102 - error: the parameter 'shouldThrow' is copied for each invocation but only used as a const reference; consider making it a const reference [performance-unnecessary-value-param,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 110 to 115 in d2902ae

exception_ptr eptr = current_exception();
if (eptr) {
try {
rethrow_exception(eptr);
} 

!Line: 110 - error: variable 'eptr' of type 'exception_ptr' can be declared 'const' [misc-const-correctness,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 119 to 124 in d2902ae

<< endl;
}
}
else {
clog << "Something was thrown, not sure what." << endl
<< "This satisfies the assertion, so no failure is" 

!Line: 119 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 123 to 128 in d2902ae

clog << "Something was thrown, not sure what." << endl
<< "This satisfies the assertion, so no failure is"
<< " present. "
<< TestFailedException("Unknown thrown object").
what();
} 

!Line: 123 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 133 to 138 in d2902ae

throw TestFailedException(std::move(failureMessage));
}
void Assertions::assertNoThrows (
const function<void()>& shouldNotThrow,
const string& failureMessage 

!Line: 133 - error: std::move of the const variable 'failureMessage' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/src/TestCPPAssertions.cpp

Lines 145 to 150 in d2902ae

throw TestFailedException(std::move(failureMessage));
}
}
void Assertions::assertTrue (
bool condition, 

!Line: 145 - error: std::move of the const variable 'failureMessage' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/src/TestCPPAssertions.cpp

Lines 164 to 169 in d2902ae

if (err.size()) {
throw TestFailedException(std::move(err));
}
}
} 

!Line: 164 - error: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 164 to 169 in d2902ae

if (err.size()) {
throw TestFailedException(std::move(err));
}
}
} 

!Line: 164 - error: implicit conversion 'size_type' (aka 'unsigned long') -> 'bool' [readability-implicit-bool-conversion,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 165 to 170 in d2902ae

throw TestFailedException(std::move(err));
}
}
}
void Assertions::assertFalse ( 

!Line: 165 - error: std::move of the const variable 'err' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/src/TestCPPAssertions.cpp

Lines 185 to 190 in d2902ae

if (err.size()) {
throw TestFailedException(std::move(err));
}
}
} 

!Line: 185 - error: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 185 to 190 in d2902ae

if (err.size()) {
throw TestFailedException(std::move(err));
}
}
} 

!Line: 185 - error: implicit conversion 'size_type' (aka 'unsigned long') -> 'bool' [readability-implicit-bool-conversion,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 186 to 191 in d2902ae

throw TestFailedException(std::move(err));
}
}
}
[[noreturn]] void Assertions::fail(string failureMessage) { 

!Line: 186 - error: std::move of the const variable 'err' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/src/TestCPPAssertions.cpp

Lines 191 to 194 in d2902ae

[[noreturn]] void Assertions::fail(string failureMessage) {
throw TestFailedException(std::move(failureMessage));
}
} 

!Line: 191 - error: the parameter 'failureMessage' is copied for each invocation but only used as a const reference; consider making it a const reference [performance-unnecessary-value-param,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 192 to 194 in d2902ae

throw TestFailedException(std::move(failureMessage));
}
} 

!Line: 192 - error: no header providing "std::move" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 92 to 97 in d2902ae

enum TestCaseOutCompareOptions {
CONTAINS,
EXACT
};
/** 

!Line: 92 - error: enum 'TestCaseOutCompareOptions' uses a larger base type ('unsigned int', size: 4 bytes) than necessary for its value set, consider using 'std::uint8_t' (1 byte) as the base type to reduce its size [performance-enum-size,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 146 to 151 in d2902ae

TestCase (const TestCase& o);
/**
* @brief Construct a TestCase by moving all data from another
* TestCase.
* @param o Move everything from this TestCase into the new one. 

!Line: 146 - error: parameter name 'o' is too short, expected at least 3 characters [readability-identifier-length,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 153 to 158 in d2902ae

TestCase (TestCase&& o) noexcept;
/**
* @brief Copy a TestCase into another TestCase.
* @param rhs The test case to copy from.
* @return A reference to the new TestCase copy. 

!Line: 153 - error: parameter name 'o' is too short, expected at least 3 characters [readability-identifier-length,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 160 to 165 in d2902ae

TestCase& operator= (const TestCase& rhs);
/**
* @brief Move a TestCase into another TestCase.
* @param rhs Move everything from this TestCase into the new
* one. 

!Line: 160 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 169 to 174 in d2902ae

TestCase& operator= (TestCase&& rhs) noexcept;
/**
* @brief Destroy a TestCase object.
*/
~TestCase (); 

!Line: 169 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 224 to 229 in d2902ae

bool checkStdout (const string& against);
/**
* @brief Check the argument against what is captured from
* std::clog using the configured comparison mode.
* @param against The value to check the captured output against 

!Line: 224 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 233 to 238 in d2902ae

bool checkLog (const string& against);
/**
* @brief Check the argument against what is captured from
* stderr using the configured comparison mode.
* @param against The value to check the captured output against 

!Line: 233 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 243 to 248 in d2902ae

bool checkStderr (const string& against);
/**
* @brief Run the test case.
* @return True if the test ran successfully, false otherwise.
*/ 

!Line: 243 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 249 to 254 in d2902ae

bool go ();
/**
* @brief Returns the duration of the last run in nanoseconds.
* @return The duration of the last run of this TestCase in
* nanoseconds. 

!Line: 249 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 256 to 261 in d2902ae

long long getLastRuntime () const;
private:
bool notifyTestPassed = false;
bool pass = false;
bool stdoutCaptured = false; 

!Line: 256 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 315 to 320 in d2902ae

bool checkOutput (const string& source, const string& against);
static atomic_int stdoutCaptureCasesConstructed;
static atomic_int logCaptureCasesConstructed;
static atomic_int stderrCaptureCasesConstructed;
static atomic_int stdoutCaptureCasesDestroyed; 

!Line: 315 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 345 to 350 in d2902ae

static nanoseconds duration (const F& func, Args&&... args)
{
auto start = system_clock::now();
func(forward<Args>(args)...);
return duration_cast<nanoseconds>(
system_clock::now() - start 

!Line: 345 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestSuite.h

Lines 79 to 84 in d2902ae

TestSuite (TestObjName&& newSuiteName,
typename enable_if<sizeof...(TestType) == 0>::type)
{
commonInit(std::forward<TestObjName>(newSuiteName));
} 

!Line: 79 - error: constructor does not initialize these fields: firstRun, testSuitePassedMessage, lastRunSucceeded, lastRunSuccessCount, lastRunFailCount, totalRuntime [cppcoreguidelines-pro-type-member-init,hicpp-member-init,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestSuite.h

Lines 79 to 84 in d2902ae

TestSuite (TestObjName&& newSuiteName,
typename enable_if<sizeof...(TestType) == 0>::type)
{
commonInit(std::forward<TestObjName>(newSuiteName));
} 

!Line: 79 - error: rvalue reference parameter 'newSuiteName' is never moved from inside the function body [cppcoreguidelines-rvalue-reference-param-not-moved,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestSuite.h

Lines 80 to 85 in d2902ae

typename enable_if<sizeof...(TestType) == 0>::type)
{
commonInit(std::forward<TestObjName>(newSuiteName));
}
/** 

!Line: 80 - error: all parameters should be named in a function [hicpp-named-parameter,readability-named-parameter,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestSuite.h

Lines 90 to 95 in d2902ae

TestSuite (TestObjName&& newSuiteName, TestType ...tests)
{
commonInit(std::forward<TestObjName>(newSuiteName));
this->addTests(tests...);
} 

!Line: 90 - error: constructor does not initialize these fields: firstRun, testSuitePassedMessage, lastRunSucceeded, lastRunSuccessCount, lastRunFailCount, totalRuntime [cppcoreguidelines-pro-type-member-init,hicpp-member-init,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestSuite.h

Lines 90 to 95 in d2902ae

TestSuite (TestObjName&& newSuiteName, TestType ...tests)
{
commonInit(std::forward<TestObjName>(newSuiteName));
this->addTests(tests...);
} 

!Line: 90 - error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [hicpp-explicit-conversions,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestSuite.h

Lines 90 to 95 in d2902ae

TestSuite (TestObjName&& newSuiteName, TestType ...tests)
{
commonInit(std::forward<TestObjName>(newSuiteName));
this->addTests(tests...);
} 

!Line: 90 - error: rvalue reference parameter 'newSuiteName' is never moved from inside the function body [cppcoreguidelines-rvalue-reference-param-not-moved,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestSuite.h

Lines 112 to 117 in d2902ae

static inline addTests () { }
/**
* @brief Add one or more tests at once to the test suite.
* @param test The first test to add.
* @param tests The rest of the tests to add. 

!Line: 112 - error: function 'addTests' has inline specifier but is implicitly inlined [readability-redundant-inline-specifier,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestSuite.h

Lines 112 to 117 in d2902ae

static inline addTests () { }
/**
* @brief Add one or more tests at once to the test suite.
* @param test The first test to add.
* @param tests The rest of the tests to add. 

!Line: 112 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestSuite.h

Lines 148 to 153 in d2902ae

unsigned getLastRunFailCount () const;
/**
* @brief Retrieve the total number of tests in the suite that
* succeeded (passed) during the last suite run.
* @return The total number of tests that passed in the last 

!Line: 148 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestSuite.h

Lines 156 to 161 in d2902ae

unsigned getLastRunSuccessCount() const;
/**
* @brief Run all tests in the test suite.
*/
void run (); 

!Line: 156 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestSuite.h

Lines 181 to 186 in d2902ae

void commonInit(TestObjName&& newSuiteName) {
this->firstRun = true;
this->testSuitePassedMessage = true;
this->lastRunSucceeded = true;
this->lastRunFailCount = zeroInit; 

!Line: 181 - error: rvalue reference parameter 'newSuiteName' is never moved from inside the function body [cppcoreguidelines-rvalue-reference-param-not-moved,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 36 to 41 in d2902ae

using std::cerr;
using std::clog;
using std::cout;
using std::endl;
using std::exception;
using std::fixed; 

!Line: 36 - error: no header providing "std::cerr" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 37 to 42 in d2902ae

using std::clog;
using std::cout;
using std::endl;
using std::exception;
using std::fixed;
using std::function; 

!Line: 37 - error: no header providing "std::clog" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 38 to 43 in d2902ae

using std::cout;
using std::endl;
using std::exception;
using std::fixed;
using std::function;
using std::invalid_argument; 

!Line: 38 - error: no header providing "std::cout" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 38 to 43 in d2902ae

using std::cout;
using std::endl;
using std::exception;
using std::fixed;
using std::function;
using std::invalid_argument; 

!Line: 38 - error: using decl 'cout' is unused [misc-unused-using-decls,-warnings-as-errors]

!Line: 38 - note: remove the using

TestCPP/src/TestCPPTestSuite.cpp

Lines 40 to 45 in d2902ae

using std::exception;
using std::fixed;
using std::function;
using std::invalid_argument;
using std::ostream;
using std::rethrow_exception; 

!Line: 40 - error: no header providing "std::exception" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 41 to 46 in d2902ae

using std::fixed;
using std::function;
using std::invalid_argument;
using std::ostream;
using std::rethrow_exception;
using std::runtime_error; 

!Line: 41 - error: no header providing "std::fixed" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 42 to 47 in d2902ae

using std::function;
using std::invalid_argument;
using std::ostream;
using std::rethrow_exception;
using std::runtime_error;
using std::setprecision; 

!Line: 42 - error: no header providing "std::function" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 43 to 48 in d2902ae

using std::invalid_argument;
using std::ostream;
using std::rethrow_exception;
using std::runtime_error;
using std::setprecision;
using std::string; 

!Line: 43 - error: no header providing "std::invalid_argument" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 43 to 48 in d2902ae

using std::invalid_argument;
using std::ostream;
using std::rethrow_exception;
using std::runtime_error;
using std::setprecision;
using std::string; 

!Line: 43 - error: using decl 'invalid_argument' is unused [misc-unused-using-decls,-warnings-as-errors]

!Line: 43 - note: remove the using

TestCPP/src/TestCPPTestSuite.cpp

Lines 44 to 49 in d2902ae

using std::ostream;
using std::rethrow_exception;
using std::runtime_error;
using std::setprecision;
using std::string;
using std::tuple; 

!Line: 44 - error: no header providing "std::ostream" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 45 to 50 in d2902ae

using std::rethrow_exception;
using std::runtime_error;
using std::setprecision;
using std::string;
using std::tuple; 

!Line: 45 - error: no header providing "std::rethrow_exception" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 45 to 50 in d2902ae

using std::rethrow_exception;
using std::runtime_error;
using std::setprecision;
using std::string;
using std::tuple; 

!Line: 45 - error: using decl 'rethrow_exception' is unused [misc-unused-using-decls,-warnings-as-errors]

!Line: 45 - note: remove the using

TestCPP/src/TestCPPTestSuite.cpp

Lines 46 to 51 in d2902ae

using std::runtime_error;
using std::setprecision;
using std::string;
using std::tuple;
using TCPPNum = TestCPP::TestCPPCommon::Nums; 

!Line: 46 - error: no header providing "std::runtime_error" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 46 to 51 in d2902ae

using std::runtime_error;
using std::setprecision;
using std::string;
using std::tuple;
using TCPPNum = TestCPP::TestCPPCommon::Nums; 

!Line: 46 - error: using decl 'runtime_error' is unused [misc-unused-using-decls,-warnings-as-errors]

!Line: 46 - note: remove the using

TestCPP/src/TestCPPTestSuite.cpp

Lines 48 to 53 in d2902ae

using std::string;
using std::tuple;
using TCPPNum = TestCPP::TestCPPCommon::Nums;
using TCPPStr = TestCPP::TestCPPCommon::Strings; 

!Line: 48 - error: no header providing "std::string" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 49 to 54 in d2902ae

using std::tuple;
using TCPPNum = TestCPP::TestCPPCommon::Nums;
using TCPPStr = TestCPP::TestCPPCommon::Strings;
namespace TestCPP { 

!Line: 49 - error: no header providing "std::tuple" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 69 to 74 in d2902ae

void TestSuite::setSuiteName (TestObjName&& testSuiteName) {
this->suiteName = std::move(testSuiteName);
}
unsigned TestSuite::getLastRunFailCount () const {
return this->lastRunFailCount; 

!Line: 69 - error: no header providing "TestCPP::TestObjName" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 70 to 75 in d2902ae

this->suiteName = std::move(testSuiteName);
}
unsigned TestSuite::getLastRunFailCount () const {
return this->lastRunFailCount;
} 

!Line: 70 - error: no header providing "std::move" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 73 to 78 in d2902ae

unsigned TestSuite::getLastRunFailCount () const {
return this->lastRunFailCount;
}
unsigned TestSuite::getLastRunSuccessCount() const {
return this->lastRunSuccessCount; 

!Line: 73 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 77 to 82 in d2902ae

unsigned TestSuite::getLastRunSuccessCount() const {
return this->lastRunSuccessCount;
}
void TestSuite::run () {
if (this->tests.size() == 0) { 

!Line: 77 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 82 to 87 in d2902ae

if (this->tests.size() == 0) {
clog << TCPPStr::NTR << endl;
return;
}
if (!this->firstRun) { 

!Line: 82 - error: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 83 to 88 in d2902ae

clog << TCPPStr::NTR << endl;
return;
}
if (!this->firstRun) {
this->lastRunSucceeded = true; 

!Line: 83 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 97 to 102 in d2902ae

clog << endl
<< TCPPStr::START_RUN << TCPPStr::SUITE
<< TCPPStr::APOS << this->suiteName << TCPPStr::APOS
<< endl
<< endl; 

!Line: 97 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 100 to 105 in d2902ae

<< endl
<< endl;
for (TestCase test : this->tests) {
bool testPassed = false;
try { 

!Line: 100 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 101 to 106 in d2902ae

<< endl;
for (TestCase test : this->tests) {
bool testPassed = false;
try {
testPassed = test.go(); 

!Line: 101 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 110 to 115 in d2902ae

<< endl;
}
catch (...) {
cerr << TCPPStr::UNK_EXC
<< endl;
} 

!Line: 110 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 114 to 119 in d2902ae

<< endl;
}
if (!testPassed) {
this->lastRunFailCount++; 

!Line: 114 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 131 to 136 in d2902ae

clog << endl;
if (this->testSuitePassedMessage &&
this->lastRunFailCount == 0) {
clog << TCPPStr::ALL << TCPPStr::APOS << this->suiteName
<< TCPPStr::APOS << TCPPStr::SUITE_TESTS_PASSED 

!Line: 131 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 137 to 142 in d2902ae

<< endl;
}
double suiteRuntimeElapsed = static_cast<double>(
this->totalRuntime)/TCPPNum::NANOS_IN_SEC; 

!Line: 137 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 140 to 145 in d2902ae

double suiteRuntimeElapsed = static_cast<double>(
this->totalRuntime)/TCPPNum::NANOS_IN_SEC;
clog << fixed;
clog << setprecision(0);
clog << TCPPStr::FINISHED_SUITE << TCPPStr::APOS 

!Line: 140 - error: variable 'suiteRuntimeElapsed' of type 'double' can be declared 'const' [misc-const-correctness,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 151 to 156 in d2902ae

<< endl;
}
/**
* @brief Add a test to this test suite.
* 

!Line: 151 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 160 to 165 in d2902ae

void TestSuite::addTest (TestCase&& test) {
this->tests.emplace_back(test);
}
/**
* @brief Add a test to this test suite. 

!Line: 160 - error: rvalue reference parameter 'test' is never moved from inside the function body [cppcoreguidelines-rvalue-reference-param-not-moved,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 173 to 178 in d2902ae

test)
{
this->tests.emplace_back(
std::get<0>(test),
std::get<1>(test),
this->testSuitePassedMessage 

!Line: 173 - error: rvalue reference parameter 'test' is never moved from inside the function body [cppcoreguidelines-rvalue-reference-param-not-moved,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 110 to 115 in d2902ae

template <class... Ts> no_destroy(Ts&&... ts) { new (data) T(std::forward<Ts>(ts)...); }
T& get() { return *reinterpret_cast<T*>(data); }
};
/**
* @brief Log a message that will only be output when debug 

!Line: 110 - error: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay,hicpp-no-array-decay,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 45 to 50 in d2902ae

using std::cerr;
using std::clog;
using std::cout;
using std::endl;
using std::exception;
using std::fixed; 

!Line: 45 - error: no header providing "std::cerr" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 46 to 51 in d2902ae

using std::clog;
using std::cout;
using std::endl;
using std::exception;
using std::fixed;
using std::function; 

!Line: 46 - error: no header providing "std::clog" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 47 to 52 in d2902ae

using std::cout;
using std::endl;
using std::exception;
using std::fixed;
using std::function;
using std::invalid_argument; 

!Line: 47 - error: no header providing "std::cout" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 49 to 54 in d2902ae

using std::exception;
using std::fixed;
using std::function;
using std::invalid_argument;
using std::rethrow_exception;
using std::runtime_error; 

!Line: 49 - error: no header providing "std::exception" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 50 to 55 in d2902ae

using std::fixed;
using std::function;
using std::invalid_argument;
using std::rethrow_exception;
using std::runtime_error;
using std::setprecision; 

!Line: 50 - error: no header providing "std::fixed" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 51 to 56 in d2902ae

using std::function;
using std::invalid_argument;
using std::rethrow_exception;
using std::runtime_error;
using std::setprecision;
using std::string; 

!Line: 51 - error: no header providing "std::function" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 52 to 57 in d2902ae

using std::invalid_argument;
using std::rethrow_exception;
using std::runtime_error;
using std::setprecision;
using std::string;
using std::tuple; 

!Line: 52 - error: no header providing "std::invalid_argument" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 52 to 57 in d2902ae

using std::invalid_argument;
using std::rethrow_exception;
using std::runtime_error;
using std::setprecision;
using std::string;
using std::tuple; 

!Line: 52 - error: using decl 'invalid_argument' is unused [misc-unused-using-decls,-warnings-as-errors]

!Line: 52 - note: remove the using

TestCPP/src/TestCPPTestCase.cpp

Lines 53 to 58 in d2902ae

using std::rethrow_exception;
using std::runtime_error;
using std::setprecision;
using std::string;
using std::tuple; 

!Line: 53 - error: no header providing "std::rethrow_exception" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 53 to 58 in d2902ae

using std::rethrow_exception;
using std::runtime_error;
using std::setprecision;
using std::string;
using std::tuple; 

!Line: 53 - error: using decl 'rethrow_exception' is unused [misc-unused-using-decls,-warnings-as-errors]

!Line: 53 - note: remove the using

TestCPP/src/TestCPPTestCase.cpp

Lines 54 to 59 in d2902ae

using std::runtime_error;
using std::setprecision;
using std::string;
using std::tuple;
using TCPPNum = TestCPP::TestCPPCommon::Nums; 

!Line: 54 - error: no header providing "std::runtime_error" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 54 to 59 in d2902ae

using std::runtime_error;
using std::setprecision;
using std::string;
using std::tuple;
using TCPPNum = TestCPP::TestCPPCommon::Nums; 

!Line: 54 - error: using decl 'runtime_error' is unused [misc-unused-using-decls,-warnings-as-errors]

!Line: 54 - note: remove the using

TestCPP/src/TestCPPTestCase.cpp

Lines 56 to 61 in d2902ae

using std::string;
using std::tuple;
using TCPPNum = TestCPP::TestCPPCommon::Nums;
using TCPPStr = TestCPP::TestCPPCommon::Strings; 

!Line: 56 - error: no header providing "std::string" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 57 to 62 in d2902ae

using std::tuple;
using TCPPNum = TestCPP::TestCPPCommon::Nums;
using TCPPStr = TestCPP::TestCPPCommon::Strings;
namespace TestCPP { 

!Line: 57 - error: no header providing "std::tuple" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 57 to 62 in d2902ae

using std::tuple;
using TCPPNum = TestCPP::TestCPPCommon::Nums;
using TCPPStr = TestCPP::TestCPPCommon::Strings;
namespace TestCPP { 

!Line: 57 - error: using decl 'tuple' is unused [misc-unused-using-decls,-warnings-as-errors]

!Line: 57 - note: remove the using

TestCPP/src/TestCPPTestCase.cpp

Lines 64 to 69 in d2902ae

atomic_int TestCase::stdoutCaptureCasesConstructed;
atomic_int TestCase::logCaptureCasesConstructed;
atomic_int TestCase::stderrCaptureCasesConstructed;
atomic_int TestCase::stdoutCaptureCasesDestroyed;
atomic_int TestCase::logCaptureCasesDestroyed;
atomic_int TestCase::stderrCaptureCasesDestroyed; 

!Line: 64 - error: no header providing "atomic_int" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 72 to 77 in d2902ae

TestCase::stdoutBuffer =
no_destroy<unique_ptr<stringstream, void(*)(stringstream*)>>(
unique_ptr<stringstream, void(*)(stringstream*)>(
nullptr, [](stringstream*){}
)
); 

!Line: 72 - error: initialization of 'stdoutBuffer' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp,-warnings-as-errors]

!Line: 110 - note: possibly throwing constructor declared here

TestCPP/src/TestCPPTestCase.cpp

Lines 79 to 84 in d2902ae

TestCase::clogBuffer =
no_destroy<unique_ptr<stringstream, void(*)(stringstream*)>>(
unique_ptr<stringstream, void(*)(stringstream*)>(
nullptr, [](stringstream*){}
)
); 

!Line: 79 - error: initialization of 'clogBuffer' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp,-warnings-as-errors]

!Line: 110 - note: possibly throwing constructor declared here

TestCPP/src/TestCPPTestCase.cpp

Lines 86 to 91 in d2902ae

TestCase::stderrBuffer =
no_destroy<unique_ptr<stringstream, void(*)(stringstream*)>>(
unique_ptr<stringstream, void(*)(stringstream*)>(
nullptr, [](stringstream*){}
)
); 

!Line: 86 - error: initialization of 'stderrBuffer' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp,-warnings-as-errors]

!Line: 110 - note: possibly throwing constructor declared here

TestCPP/src/TestCPPTestCase.cpp

Lines 93 to 98 in d2902ae

TestCase::stdoutOriginal =
no_destroy<unique_ptr<streambuf, void(*)(streambuf*)>>(
unique_ptr<streambuf, void(*)(streambuf*)>(
nullptr, [](streambuf*){}
)
); 

!Line: 93 - error: initialization of 'stdoutOriginal' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp,-warnings-as-errors]

!Line: 110 - note: possibly throwing constructor declared here

TestCPP/src/TestCPPTestCase.cpp

Lines 100 to 105 in d2902ae

TestCase::clogOriginal =
no_destroy<unique_ptr<streambuf, void(*)(streambuf*)>>(
unique_ptr<streambuf, void(*)(streambuf*)>(
nullptr, [](streambuf*){}
)
); 

!Line: 100 - error: initialization of 'clogOriginal' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp,-warnings-as-errors]

!Line: 110 - note: possibly throwing constructor declared here

TestCPP/src/TestCPPTestCase.cpp

Lines 107 to 112 in d2902ae

TestCase::stderrOriginal =
no_destroy<unique_ptr<streambuf, void(*)(streambuf*)>>(
unique_ptr<streambuf, void(*)(streambuf*)>(
nullptr, [](streambuf*){}
)
); 

!Line: 107 - error: initialization of 'stderrOriginal' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp,-warnings-as-errors]

!Line: 110 - note: possibly throwing constructor declared here

TestCPP/src/TestCPPTestCase.cpp

Lines 121 to 126 in d2902ae

this->notifyTestPassed = testPassedMessage;
this->test = std::move(testFn);
this->testName = std::move(name);
if (captureOut) { 

!Line: 121 - error: 'notifyTestPassed' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 123 to 128 in d2902ae

this->test = std::move(testFn);
this->testName = std::move(name);
if (captureOut) {
captureStdout();
} 

!Line: 123 - error: 'test' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 123 to 128 in d2902ae

this->test = std::move(testFn);
this->testName = std::move(name);
if (captureOut) {
captureStdout();
} 

!Line: 123 - error: no header providing "std::move" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 124 to 129 in d2902ae

this->testName = std::move(name);
if (captureOut) {
captureStdout();
}
if (captureLog) { 

!Line: 124 - error: 'testName' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 124 to 129 in d2902ae

this->testName = std::move(name);
if (captureOut) {
captureStdout();
}
if (captureLog) { 

!Line: 124 - error: no header providing "std::move" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 145 to 150 in d2902ae

TestCase::TestCase (const TestCase& o) {
this->outCompareOption(o.option);
this->setNotifyPassed(o.notifyTestPassed);
this->pass = o.pass;
this->lastRunTime = o.lastRunTime; 

!Line: 145 - error: parameter name 'o' is too short, expected at least 3 characters [readability-identifier-length,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 149 to 154 in d2902ae

this->pass = o.pass;
this->lastRunTime = o.lastRunTime;
this->stdoutCaptured = o.stdoutCaptured;
this->clogCaptured = o.clogCaptured;
this->stderrCaptured = o.stderrCaptured; 

!Line: 149 - error: 'pass' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 150 to 155 in d2902ae

this->lastRunTime = o.lastRunTime;
this->stdoutCaptured = o.stdoutCaptured;
this->clogCaptured = o.clogCaptured;
this->stderrCaptured = o.stderrCaptured; 

!Line: 150 - error: 'lastRunTime' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 152 to 157 in d2902ae

this->stdoutCaptured = o.stdoutCaptured;
this->clogCaptured = o.clogCaptured;
this->stderrCaptured = o.stderrCaptured;
if (this->stdoutCaptured) {
captureStdout(); 

!Line: 152 - error: 'stdoutCaptured' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 153 to 158 in d2902ae

this->clogCaptured = o.clogCaptured;
this->stderrCaptured = o.stderrCaptured;
if (this->stdoutCaptured) {
captureStdout();
} 

!Line: 153 - error: 'clogCaptured' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 154 to 159 in d2902ae

this->stderrCaptured = o.stderrCaptured;
if (this->stdoutCaptured) {
captureStdout();
}
if (this->clogCaptured) { 

!Line: 154 - error: 'stderrCaptured' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 170 to 175 in d2902ae

TestCase::TestCase (TestCase&& o) noexcept {
this->option = std::move(o.option);
this->setNotifyPassed(std::move(o.notifyTestPassed));
this->pass = std::move(o.pass); 

!Line: 170 - error: parameter name 'o' is too short, expected at least 3 characters [readability-identifier-length,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 171 to 176 in d2902ae

this->option = std::move(o.option);
this->setNotifyPassed(std::move(o.notifyTestPassed));
this->pass = std::move(o.pass);
this->lastRunTime = std::move(o.lastRunTime); 

!Line: 171 - error: 'option' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 171 to 176 in d2902ae

this->option = std::move(o.option);
this->setNotifyPassed(std::move(o.notifyTestPassed));
this->pass = std::move(o.pass);
this->lastRunTime = std::move(o.lastRunTime); 

!Line: 171 - error: std::move of the expression of the trivially-copyable type 'TestCaseOutCompareOptions' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 171 to 176 in d2902ae

this->option = std::move(o.option);
this->setNotifyPassed(std::move(o.notifyTestPassed));
this->pass = std::move(o.pass);
this->lastRunTime = std::move(o.lastRunTime); 

!Line: 171 - error: no header providing "std::move" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 173 to 178 in d2902ae

this->setNotifyPassed(std::move(o.notifyTestPassed));
this->pass = std::move(o.pass);
this->lastRunTime = std::move(o.lastRunTime);
this->stdoutCaptured = std::move(o.stdoutCaptured); 

!Line: 173 - error: std::move of the expression of the trivially-copyable type 'bool' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]



!Maximum character count per GitHub comment has been reached! Not all warnings/errors has been parsed!

eljonny added 2 commits June 3, 2025 01:43
@eljonny
Fix backtrace and addr2line issues
1b11cf1 
Use find_package, as that is how FindBacktrace is intended to be used.
No need to call FindBinUtils, this CMake find module is loaded during
 CMake initialization.
@eljonny
Boost.Stacktrace requires winapi on all platforms.
b393d0c
@codecov Codecov
Copy link

codecov bot commented Jun 3, 2025 •
edited
Loading

Codecov Report

All modified and coverable lines are covered by tests ✅

Project coverage is 87.44%. Comparing base (69a19b2) to head (d2902ae).
Report is 13 commits behind head on main.

✅ All tests successful. No failed tests found.

Additional details and impacted files 
@@           Coverage Diff           @@
##             main     #116   +/-   ##
=======================================
  Coverage   87.44%   87.44%           
=======================================
  Files          10       10           
  Lines         486      486           
  Branches       61       61           
=======================================
  Hits          425      425           
  Misses         52       52           
  Partials        9        9

☔ View full report in Codecov by Sentry.
📢 Have feedback on the report? Share it here.

@eljonny eljonny merged commit bbac97c into main Jun 3, 2025
41 of 42 checks passed
@eljonny eljonny deleted the convert-boost-stacktrace-to-git-submodule branch June 3, 2025 09:19
@eljonny eljonny mentioned this pull request Jun 9, 2025
Closed
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Reviewers

No reviews

Assignees

@eljonny eljonny

Labels

enhancement New feature or request

Projects

None yet

Milestone

0.8-release

Development

Successfully merging this pull request may close these issues.

Convert Boost::stacktrace to a git submodule and dynamic CMake dependency

1 participant

@eljonny